home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / lisp / wgdb-42.lha / wgdb-4.2 / gdb / tdesc.c < prev    next >
C/C++ Source or Header  |  1992-09-11  |  50KB  |  1,651 lines
  1. /* This file has been modified by Data General Corporation, November 1989. */
  2.  
  3. /*
  4. This file provides an abstract interface to "tdesc" information.
  5.       It is designed to be used in a uniform manner by several kinds
  6.       of debuggers:
  7.          (1) code in live debugged process (e.g., a traceback routine)
  8.          (2) a separate-process debugger debugging a live process
  9.          (3) a separate-process debugger debugging a memory dump
  10.  
  11.       Dcontext model notes
  12.          * captures machine context
  13.             * partial: excludes memory
  14.          * frames
  15.             * kinds
  16.          * make one for starters, chain in reverse order to previous ones
  17.          * representation: pointer to opaque
  18.             * alloc/free protocol
  19.  
  20.       Overall model
  21.          * access functions
  22.          * handle
  23.          * error handling
  24. */
  25.  
  26.  
  27.  
  28. typedef int dc_boolean_t;   /* range 0 .. 1 */
  29. #define DC_FALSE 0
  30. #define DC_TRUE 1
  31.  
  32.  
  33. typedef int dc_tristate_t;  /* range 0 .. 2 */
  34. #define DC_NO 0
  35. #define DC_YES 1
  36. #define DC_MAYBE 2
  37.  
  38.  
  39. /*
  40.    A word is 32 bits of information.  In memory, a word is word-aligned.
  41.  
  42.    A common and important use of dc_word_t is to represent values in the
  43.    target process, including (byte) addresses in the target process.
  44.    In this case, C arithmetic can be used to simulate machine address
  45.    arithmetic on the target.  (Unsigned arithmetic is actually modulus
  46.    arithmetic.)
  47. */
  48. typedef unsigned int dc_word_t;
  49.  
  50.  
  51. /* These bit operations number bits from 0 at the least significant end. */
  52. #define bit_test(word,bit) ((word) & (1 << (bit)))    /* returns 0 or other */
  53. #define bit_value(word,bit) (((word) >> (bit)) & 1)   /* returns 0 or 1 */
  54. #define bit_set(word,bit) ((word) |= (1 << (bit)))
  55. #define bit_clear(word,bit) ((word) &= ~(1 << (bit)))
  56. #define bit_assign(word, bit, bool) \
  57.    if (bool) bit_set(word, bit); else bit_clear(word, bit)
  58.  
  59.  
  60. /*----------------*/
  61.  
  62.  
  63. /* The exactness of locations may not be certainly known. */
  64. typedef dc_tristate_t dc_exactness_t;
  65.  
  66.  
  67. /*
  68.    The model includes five kinds of contexts.  Because each context
  69.    has an associated region and frame, these describe region kinds
  70.    and frame kinds as well.
  71.    [more description needed]
  72.    Currently, only call contexts exist.
  73. */
  74.  
  75. typedef int dc_kind_t;   /* range 0 .. 4 */
  76. #define DC_CALL_KIND          0
  77. #define DC_SAVE_KIND          1
  78. #define DC_EXCEPTION_KIND     2
  79. #define DC_PROTECTION_KIND    3
  80. #define DC_SPECIAL_KIND       4
  81. #define DC_NUM_KINDS          5
  82.  
  83. #define DC_MIO_ENTRY_POINT            (1<< 0)
  84. #define DC_MIO_PROLOGUE_END           (1<< 1)
  85. #define DC_MIO_EPILOGUE_START         (1<< 2)
  86. #define DC_MIO_IMPLICIT_PROLOGUE_END  (1<<16)
  87. #define DC_MIO_LITERAL_ENTRY_POINT    (1<<17)
  88. #define DC_MIO_LITERAL_EPILOGUE_START (1<<18)
  89.  
  90. #define DC_MII_PRECEDING_TDESC_END   (1<<0)
  91. #define DC_MII_FOLLOWING_TDESC_START (1<<1)
  92.  
  93. typedef struct dc_debug_info {
  94.    unsigned int         protocol;            /* 1 for this structure */
  95.    dc_word_t               tdesc_ptr;
  96.    unsigned int         text_words_count;
  97.    dc_word_t               text_words_ptr;
  98.    unsigned int         data_words_count;
  99.    dc_word_t               data_words_ptr;
  100. } dc_debug_info_t;
  101.  
  102.  
  103. typedef struct tdesc_hdr {
  104.    unsigned int         map_protocol;        /* 1 for this structure */
  105.    unsigned int         end;                 /* address beyond end */
  106. } tdesc_hdr_t;
  107.  
  108.  
  109. typedef struct tdesc_chunk_hdr {
  110.    int                  zeroes : 8;
  111.    int                  info_length : 22;
  112.    int                  info_alignment : 2;
  113.    unsigned int         info_protocol;
  114.    dc_word_t               start_address;
  115.    dc_word_t               end_address;
  116. } tdesc_chunk_hdr_t;
  117.  
  118.  
  119. typedef struct tdesc_chunk_info1 {
  120.    int                  variant : 8;         /* 1 for this structure */
  121.    int                  register_save_mask : 17;
  122.    int                  pad1 : 1;
  123.    int                  return_address_info_discriminant : 1;
  124.    int                  frame_address_register : 5;
  125.    unsigned int         frame_address_offset;
  126.    unsigned int         return_address_info;
  127.    unsigned int         register_save_offset;
  128. } tdesc_chunk_info1_t;
  129.  
  130.  
  131. typedef struct tdesc_chunk1 {
  132.    tdesc_chunk_hdr_t    hdr;
  133.    tdesc_chunk_info1_t  info;
  134. } tdesc_chunk1_t;
  135.  
  136.  
  137. typedef struct dc_mstate {
  138.    dc_word_t reg[32];                      /* general registers */
  139.    dc_word_t xip;
  140.    dc_word_t nip;
  141.    dc_word_t fip;
  142.    dc_word_t fpsr;
  143.    dc_word_t fpcr;
  144.    dc_word_t psr;
  145. } dc_mstate_t;
  146.  
  147.  
  148. typedef struct dc_map_info_in {
  149.    dc_word_t flags;
  150.    dc_word_t preceding_tdesc_end;
  151.    dc_word_t following_tdesc_start;
  152. } dc_map_info_in_t;
  153.  
  154.  
  155. typedef struct dc_map_info_out {
  156.    dc_word_t flags;
  157.    dc_word_t entry_point;
  158.    dc_word_t prologue_end;
  159.    dc_word_t epilogue_start;
  160. } dc_map_info_out_t;
  161.  
  162.  
  163. #if 0
  164.  
  165.    void error_fcn (env, continuable, message)
  166.       dc_word_t env;                       /* environment (arbitrary datum) */
  167.       dc_boolean_t continuable;            /* whether error function may return */
  168.       char *message;                    /* string (no trailing newline) */
  169.  
  170.    /* In the future, we probably want the error_fcn to be: */
  171.    void error_fcn (env, continuable, code, ...)
  172.       dc_word_t env;                       /* environment (arbitrary datum) */
  173.       dc_boolean_t continuable;            /* whether error function may return */
  174.       int code;                         /* error code */
  175.       ...                               /* parameters to message associated
  176.                                            with the code */
  177.  
  178.    void read_fcn (env, memory, length, buffer)
  179.       dc_word_t env;                       /* environment (arbitrary datum) */
  180.       dc_word_t memory;                    /* start address in image */
  181.       int length;                       /* in bytes */
  182.       char *buffer;                     /* start address of buffer */
  183.       /* There are no alignment assumptions for the read function. */
  184.  
  185.    void write_fcn (env, memory, length, buffer)
  186.       dc_word_t env;                       /* environment (arbitrary datum) */
  187.       dc_word_t memory;                    /* start address in image */
  188.       int length;                       /* in bytes */
  189.       char *buffer;                     /* start address of buffer */
  190.       /* There are no alignment assumptions for the write function. */
  191.       /* The write function is optional.  It must be provided if changes
  192.          to writable registers are to be made. */
  193.  
  194.    void exec_fcn (env, mstate)
  195.       dc_word_t env;                       /* environment (arbitrary datum) */
  196.       dc_mstate_t *mstate;              /* machine state (read-write) */
  197.       /* The execute function is optional.  It would be used (in the future)
  198.          by the implementation of a procedurally specified tdesc mechanism. */
  199.  
  200. #endif
  201.  
  202. /*----------------*/
  203.  
  204.  
  205. #ifndef NULL
  206. #define NULL ((void *) 0)
  207. #endif
  208.  
  209. extern char *malloc();
  210. extern char *calloc();
  211. extern void qsort();
  212.  
  213.  
  214. /*
  215.    At initialization, create a tdesc table from the tdesc info.
  216.    A tdesc table is simply a sorted array of tdesc elements.
  217.    A tdesc element is the last 6 words of the tdesc chunk.
  218.    We require that all tdesc chunks have info protocol 1.
  219. */
  220.  
  221. typedef struct tdesc_elem {
  222.    dc_word_t start_address;
  223.    dc_word_t end_address;
  224.    tdesc_chunk_info1_t info;
  225. } tdesc_elem_t;
  226.  
  227. typedef tdesc_elem_t *tdesc_table_t;
  228.  
  229. void dc_correct_cr_data();
  230.  
  231. int dc_compare_tdesc_elems (elem1, elem2)
  232.    char *elem1, *elem2;
  233. {
  234.    dc_word_t s1, s2, e1, e2;
  235.    s1 = ((tdesc_elem_t *) elem1)->start_address;
  236.    s2 = ((tdesc_elem_t *) elem2)->start_address;
  237.    if (s1 < s2) return -1;
  238.    if (s1 > s2) return +1;
  239.    e1 = ((tdesc_elem_t *) elem1)->end_address;
  240.    e2 = ((tdesc_elem_t *) elem2)->end_address;
  241.    if (e1 < e2) return -1;
  242.    if (e1 > e2) return +1;
  243.    return 0;
  244. }
  245.  
  246.  
  247. typedef struct handle_info {
  248.    dc_word_t debug_info_ptr;
  249.    void (*error_fcn)();
  250.    dc_word_t error_env;
  251.    void (*read_fcn)();
  252.    dc_word_t read_env;
  253.    void (*write_fcn)();                 /* NULL => absent */
  254.    dc_word_t write_env;
  255.    void (*exec_fcn)();                  /* NULL => absent */
  256.    dc_word_t exec_env;
  257.    void (*map_fcn)();                  /* NULL => absent */
  258.    dc_word_t map_env;
  259.    tdesc_table_t tdesc_table;
  260.    int tdesc_table_size;
  261. } handle_info_t;
  262.  
  263. typedef handle_info_t *dc_handle_t;
  264.  
  265.  
  266. /*
  267.    Errors detected in this module are funnelled through dc_error or dc_warn,
  268.    as appropriate.  Both routines call dc_exception, which invokes the error
  269.    handler supplied by the user.
  270.  
  271.    Currently, dc_exception substitutes parameters into the message given
  272.    it and passes the resulting string to the user error handler.
  273.    In the future, dc_exception should simply pass an error code and
  274.    the parameters on to the user error handler.
  275. */
  276.  
  277. #include <varargs.h>
  278. extern int vsprintf();
  279.  
  280. /* Exit status for exception-processing machinery failure */
  281. #define DC_EXCEPTION_FAILURE    250
  282.  
  283. void dc_exception(continuable, args)
  284.    dc_boolean_t continuable;
  285.    va_list args;
  286. {
  287.    dc_handle_t handle;
  288.    char *format;
  289.    char buffer[1024];
  290.  
  291.    handle = va_arg(args, dc_handle_t);
  292.    format = va_arg(args, char *);
  293.    (void) vsprintf(buffer, format, args);
  294.    (*(handle->error_fcn)) (handle->error_env, continuable, buffer);
  295.    if (!continuable)
  296.       exit(DC_EXCEPTION_FAILURE);  /* User error handler should never return in this case. */
  297. }
  298.  
  299.  
  300. void dc_error(va_alist)  /* (handle, format, args... ) */
  301.    va_dcl
  302. {
  303.    va_list args;
  304.  
  305.    va_start(args);
  306.    dc_exception(DC_FALSE, args);
  307.    va_end(args);
  308. }
  309.  
  310.  
  311. void dc_warn(va_alist)  /* (handle, format, args... ) */
  312.    va_dcl
  313. {
  314.    va_list args;
  315.  
  316.    va_start(args);
  317.    dc_exception(DC_TRUE, args);
  318.    va_end(args);
  319. }
  320.  
  321.  
  322.  
  323. #define MALLOC_FAILURE_MESSAGE "Heap space exhausted (malloc failed)."
  324. #define CALLOC_FAILURE_MESSAGE "Heap space exhausted (Calloc failed)."
  325.  
  326.  
  327. /* Commonize memory allocation call so failure diagnosis is easier */
  328.  
  329. char* dc_malloc( handle, size )
  330.     dc_handle_t handle;
  331.     int         size;
  332. {
  333.     char* space = malloc( size );
  334.     if (space == (char *)NULL)
  335.         dc_error( handle, MALLOC_FAILURE_MESSAGE );
  336.  
  337.     return space;
  338. }
  339.  
  340.  
  341. /* Commonize memory allocation call so failure diagnosis is easier */
  342.  
  343. char* dc_calloc( handle,nelem, size )
  344.     dc_handle_t handle;
  345.     int         nelem;
  346.     int        size;
  347. {
  348.     char* space = calloc( nelem, size );
  349.     if (space == (char *)NULL)
  350.         dc_error( handle, CALLOC_FAILURE_MESSAGE );
  351.  
  352.     return space;
  353. }
  354.  
  355.  
  356. dc_word_t dc_read_word (handle, address)
  357.    dc_handle_t handle;
  358.    dc_word_t address;
  359. {
  360.    dc_word_t word;
  361.    (*(handle->read_fcn)) (handle->read_env, address,
  362.                           sizeof(dc_word_t), (char *)(&(word)));
  363.    return word;
  364. }
  365.  
  366.  
  367. void dc_write_word (handle, address, value)
  368.    dc_handle_t handle;
  369.    dc_word_t address;
  370.    dc_word_t value;
  371. {
  372.    dc_word_t word;
  373.    word = value;
  374.    if (handle->write_fcn) {
  375.       (*(handle->write_fcn)) (handle->write_env, address,
  376.                               sizeof(dc_word_t), (char *)(&(word)));
  377.    } else {
  378.       dc_error (handle, "Writing is disabled.");
  379.    }
  380. }
  381.  
  382.  
  383. void dc_write_masked_word (handle, address, mask, value)
  384.    dc_handle_t handle;
  385.    dc_word_t address;
  386.    dc_word_t mask;
  387.    dc_word_t value;
  388. {
  389.    dc_write_word (handle, address,
  390.       (value & mask) | (dc_read_word(handle, address) & ~mask));
  391. }
  392.  
  393.  
  394. dc_handle_t dc_initiate (debug_info_ptr,
  395.              error_fcn, error_env,
  396.                          read_fcn, read_env,
  397.                          write_fcn, write_env,
  398.                          exec_fcn, exec_env,
  399.                          map_fcn, map_env)
  400.    dc_word_t debug_info_ptr;
  401.    void (*error_fcn)();
  402.    dc_word_t error_env;
  403.    void (*read_fcn)();
  404.    dc_word_t read_env;
  405.    void (*write_fcn)();                 /* NULL => absent */
  406.    dc_word_t write_env;
  407.    void (*exec_fcn)();                  /* NULL => absent */
  408.    dc_word_t exec_env;
  409.    void (*map_fcn)();                  /* NULL => absent */
  410.    dc_word_t map_env;
  411.    /* write_fcn may be given as NULL if no writing is required. */
  412.    /* exec_fcn may be given as NULL if no execution is required.
  413.       Currently, no execution is required.  It would be if the
  414.       implementation needed to invoke procedures in the debugged process. */
  415. {
  416.    dc_handle_t handle;
  417.    unsigned int debug_info_protocol;
  418.    dc_debug_info_t debug_info;
  419.    unsigned int tdesc_map_protocol;
  420.    tdesc_hdr_t tdesc_hdr;
  421.    dc_word_t tdesc_info_start;
  422.    dc_word_t tdesc_info_end;
  423.    dc_word_t tdesc_info_length;
  424.  
  425.    /* Set up handle enough for dc_error. */
  426.    handle = (dc_handle_t) malloc(sizeof(handle_info_t));
  427.    /* Cant use dc_malloc() as handle is being created ... */
  428.    /* if (handle == NULL) (*error_fcn)( error_env, MALLOC_FAILURE_MESSAGE ) */
  429.    handle->error_fcn = error_fcn;
  430.    handle->error_env = error_env;
  431.    handle->read_fcn = read_fcn;
  432.    handle->read_env = read_env;
  433.    handle->write_fcn = write_fcn;
  434.    handle->write_env = write_env;
  435.    handle->exec_fcn = exec_fcn;
  436.    handle->exec_env = exec_env;
  437. /****************************************************************/
  438. /* BUG 9/19/89 Found by hls.  Map functions not initialized.    */
  439. /****************************************************************/
  440.    handle->map_fcn = map_fcn;
  441.    handle->map_env = map_env;
  442.    handle->debug_info_ptr = debug_info_ptr;
  443.    handle->tdesc_table = (tdesc_table_t)NULL;
  444.  
  445.    /* Find tdesc info. */
  446.    if (debug_info_ptr) {
  447.       (*read_fcn) (read_env, debug_info_ptr, sizeof(unsigned int),
  448.            (char *)(&debug_info_protocol));
  449.       if (debug_info_protocol != 1)
  450.      dc_error (handle, "Unrecognized debug info protocol: %d",
  451.            debug_info_protocol);
  452.       (*read_fcn) (read_env, debug_info_ptr, sizeof(dc_debug_info_t),
  453.            (char *)(&debug_info));
  454.       (*read_fcn) (read_env, debug_info.tdesc_ptr, sizeof(unsigned int),
  455.            (char *)(&tdesc_map_protocol));
  456.       if (tdesc_map_protocol != 1)
  457.      dc_error (handle, "Unrecognized tdesc map protocol: %d",
  458.            tdesc_map_protocol);
  459.       (*read_fcn) (read_env, debug_info.tdesc_ptr, sizeof(tdesc_hdr_t),
  460.            (char *)(&tdesc_hdr));
  461.       tdesc_info_start = debug_info.tdesc_ptr + sizeof(tdesc_hdr_t);
  462.       tdesc_info_end = tdesc_hdr.end;
  463.       tdesc_info_length = tdesc_info_end - tdesc_info_start;
  464.  
  465.       /* Create tdesc table from tdesc info. */
  466.       {
  467.      /* Over-allocate in order to avoid second pass over tdesc info. */
  468.      tdesc_table_t tt = (tdesc_table_t) dc_malloc(handle, tdesc_info_length);
  469.      dc_word_t p = tdesc_info_start;
  470.      dc_word_t q = tdesc_info_end - sizeof(tdesc_chunk1_t);
  471.      int n = 0;
  472.      tdesc_chunk1_t chunk;
  473.      dc_word_t start_address, end_address;
  474.      int i;
  475.  
  476.      for (; p <= q; ) {
  477.         (*read_fcn) (read_env, p, sizeof(tdesc_chunk1_t), (char *)(&chunk));
  478.         if (chunk.hdr.zeroes != 0) {
  479.            /* Skip padding. */
  480.            p += sizeof(dc_word_t);
  481.            continue;
  482.         }
  483.         if (chunk.hdr.info_protocol != 1) {
  484.            dc_warn (handle, "Unrecognized tdesc info protocol: %d",
  485.              chunk.hdr.info_protocol);
  486.            goto next_chunk;
  487.         }
  488.         if (chunk.hdr.info_length != 16) {
  489.            dc_warn (handle, "Incorrect tdesc info length: %d",
  490.              chunk.hdr.info_length);
  491.            goto next_chunk;
  492.         }
  493.         if (chunk.hdr.info_alignment > 2) {
  494.            dc_warn (handle, "Incorrect tdesc info alignment: %d",
  495.              chunk.hdr.info_alignment);
  496.            goto next_chunk;
  497.         }
  498.         start_address = chunk.hdr.start_address;
  499.         end_address = chunk.hdr.end_address;
  500.         if ((start_address&3)!=0) {
  501.            dc_warn (handle,
  502.           "Tdesc start address is not word-aligned: %#.8X",
  503.           start_address);
  504.            goto next_chunk;
  505.         }
  506.         if ((end_address&3)!=0) {
  507.            dc_warn (handle,
  508.           "Tdesc end address is not word-aligned: %#.8X",
  509.           end_address);
  510.            goto next_chunk;
  511.         }
  512.         if (start_address > end_address) {
  513.              /* Note that the range may be null. */
  514.            dc_warn (handle,
  515.           "Tdesc start address (%#.8X) follows end address (%#.8X).",
  516.           start_address, end_address);
  517.            goto next_chunk;
  518.         }
  519.         if (chunk.info.variant != 1) {
  520.            dc_warn (handle, "Invalid tdesc chunk variant: %d",
  521.           chunk.info.variant);
  522.            goto next_chunk;
  523.         }
  524.         if (chunk.info.pad1 != 0) {
  525.            dc_warn (handle, "Tdesc chunk padding is not zero.");
  526.            goto next_chunk;
  527.         }
  528.         if (chunk.info.return_address_info_discriminant != 0) {
  529.            if ((chunk.info.return_address_info & 3) != 0) {
  530.           dc_warn (handle,
  531.              "Tdesc return address offset is not word-aligned: %#.8X",
  532.              chunk.info.return_address_info);
  533.           goto next_chunk;
  534.            }
  535.         } else {
  536.            if ((chunk.info.return_address_info & ~31) != 0) {
  537.           dc_warn (handle,
  538.              "Invalid tdesc return address register: %d",
  539.              chunk.info.return_address_info);
  540.           goto next_chunk;
  541.            }
  542.         }
  543.         if ((chunk.info.register_save_offset & 3) != 0) {
  544.            dc_warn (handle,
  545.           "Tdesc register save offset is not word-aligned: %#.8X",
  546.           chunk.info.register_save_offset);
  547.            goto next_chunk;
  548.         }
  549.  
  550.         tt[n].start_address = start_address;
  551.         tt[n].end_address = end_address;
  552.         tt[n].info = chunk.info;
  553.         n++;
  554.  
  555.    next_chunk:
  556.         p += sizeof(tdesc_chunk1_t);
  557.      }
  558.      /* Leftover (less than a tdesc_chunk1_t in size) is padding or
  559.         in error.  Ignore it in either case. */
  560.  
  561.      if (n != 0) {
  562.  
  563.          /* Sort table by start address. */
  564.          qsort ((char *)tt, n, sizeof(tdesc_elem_t), dc_compare_tdesc_elems);
  565.  
  566.          /* Check for overlap among tdesc chunks. */
  567.          for (i=0; i<(n-1); i++) {
  568.             if (tt[i].end_address > tt[i+1].start_address)
  569.                dc_error (handle, "Text chunks overlap.");
  570.          }
  571.      }
  572.  
  573.      /* Finish setting up handle. */
  574.      handle->tdesc_table = tt;
  575.      handle->tdesc_table_size = n;
  576.       }
  577.    } else {
  578.       handle->tdesc_table_size = 0;
  579.    }
  580.  
  581.    return (dc_handle_t) handle;
  582. }
  583.  
  584.  
  585. void dc_terminate (handle)
  586.    dc_handle_t handle;
  587. {
  588.    if (((dc_handle_t)handle)->tdesc_table) {
  589.       free((char *)(((dc_handle_t)handle)->tdesc_table));
  590.    }
  591.    free((char *)handle);
  592. }
  593.  
  594.  
  595.  
  596. /*
  597.  
  598.    Dcontext Model
  599.  
  600.    For each interesting register (word-sized piece of machine state),
  601.    a word of value information is kept.  This word may
  602.    be either the value of the register, or the address in
  603.    subject memory where the value can be found (and changed).  In
  604.    addition, the register may be invalid (in which case the value
  605.    information is undefined).  These three cases are encoded for
  606.    a given register in the same-numbered bit of two words of flags:
  607.  
  608.       flags[0] bit  flags[1] bit  meaning
  609.       ------------  ------------  -------
  610.             0             0       register is invalid; info is undefined
  611.             0             1       register is readable; info is value
  612.             1             0       register is writable; info is address
  613.             1             1       (reserved)
  614.  
  615.    The general registers (r0-r31) are handled by reg_info and
  616.    reg_flags.  The bit number for a register is that register's number.
  617.    The other registers are grouped together for convenience and are
  618.    handled by aux_info and aux_flags.  The bit numbers for these
  619.    registers are:
  620.  
  621.       bit number     register
  622.       ----------     --------
  623.            0         location
  624.            1         SXIP
  625.            2         SNIP
  626.            3         SFIP
  627.            4         FPSR
  628.            5         FPCR
  629.  
  630.    The SXIP, SNIP, and SFIP are the exception-time values of the
  631.    XIP, NIP, and FIP registers.  They are valid only in the topmost frame.
  632.    (That is, in any context obtained from dc_previous_context, they
  633.    are invalid.)
  634.  
  635.    "location" is a pseudo-register of this model and represents the
  636.    location of the context.  It is always valid.  It also has an
  637.    exactness associated with it.  The location and its exactness of a
  638.    context obtained from dc_previous_context are taken from the
  639.    return address and its exactness of the context given as an argument
  640.    to dc_previous_context.
  641.  
  642.    The following model is recommended for dealing with the partial
  643.    redundancy between location and the SXIP, SNIP, and SFIP values
  644.    in the topmost frame.  The location should be set to either the
  645.    SNIP or SXIP value, and its exactness should be set to DC_NO.  A
  646.    change to the register whose value the location is set to should
  647.    be accompanied by an identical change to the location.
  648.  
  649.    The PSR is handled separately, because it is a diverse collection
  650.    of flags.  The PSR, as a whole, is always valid.  A separate
  651.    psr_ind flag tells whether the psr_info data is a value or
  652.    an address.  Each bit of the PSR has its own pair of flag bits to
  653.    mark validity and writability.
  654.  
  655. */
  656.  
  657.  
  658. /* The following value means "other", because state is stored in 2 bits. */
  659. #define DC_RESERVED 3
  660.  
  661.  
  662. #define RSTATE(flags, bit) \
  663.    ((bit_value((flags)[0], bit) << 1) + bit_value((flags)[1], bit))
  664.  
  665. #define REG_STATE(dcontext, reg) RSTATE(dcontext->reg_flags, reg)
  666. #define AUX_STATE(dcontext, reg) RSTATE(dcontext->aux_flags, reg)
  667. #define PSR_STATE(dcontext, reg) RSTATE(dcontext->psr_flags, reg)
  668.  
  669.  
  670. #define SET_INVALID(flags, bit) \
  671.    { bit_clear ((flags)[0], bit); bit_clear ((flags)[1], bit); }
  672.  
  673. #define SET_READABLE(flags, bit) \
  674.    { bit_clear ((flags)[0], bit); bit_set   ((flags)[1], bit); }
  675.  
  676. #define SET_WRITABLE(flags, bit) \
  677.    { bit_set   ((flags)[0], bit); bit_clear ((flags)[1], bit); }
  678.  
  679. #define ASSIGN_RSTATE(to_flags, to_bit, from_flags, from_bit) \
  680.    { bit_assign ((to_flags)[0], to_bit, bit_value((from_flags)[0], from_bit));\
  681.      bit_assign ((to_flags)[1], to_bit, bit_value((from_flags)[1], from_bit));}
  682.  
  683.  
  684. #define CHECK_REG_READ(dcontext, reg) \
  685.    if (REG_STATE(dcontext, reg) == DC_INVALID) \
  686.       dc_error (dcontext->handle, \
  687.          "General register %d is not readable.", reg)
  688.  
  689. #define CHECK_REG_WRITE(dcontext, reg) \
  690.    if (REG_STATE(dcontext, reg) != DC_WRITABLE) \
  691.       dc_error (dcontext->handle, \
  692.          "General register %d is not writable.", reg)
  693.  
  694. #define CHECK_AUX_READ(dcontext, reg) \
  695.    if (AUX_STATE(dcontext, reg) == DC_INVALID) \
  696.       dc_error (dcontext->handle, \
  697.          "Auxiliary register %d is not readable.", reg)
  698.  
  699. #define CHECK_AUX_WRITE(dcontext, reg) \
  700.    if (AUX_STATE(dcontext, reg) != DC_WRITABLE) \
  701.       dc_error (dcontext->handle, \
  702.          "Auxiliary register %d is not writable.", reg)
  703.  
  704.  
  705.  
  706. #define DC_REG_RA   1
  707. #define DC_REG_FP  30
  708. #define DC_REG_SP  31
  709. #define DC_NUM_REG 32
  710.  
  711. #define DC_AUX_LOC  0
  712.    /* DC_AUX_LOC must be first, with value 0 */
  713. #define DC_AUX_SXIP 1
  714. #define DC_AUX_SNIP 2
  715. #define DC_AUX_SFIP 3
  716. #define DC_AUX_FPSR 4
  717. #define DC_AUX_FPCR 5
  718. #define DC_NUM_AUX  6
  719.  
  720.  
  721.  
  722. #define CHECK_REG(dcontext, reg) \
  723.    if ((reg < 0) || (reg >= DC_NUM_REG)) \
  724.       dc_error (dcontext->handle, \
  725.          "Bad general register number: %d", reg)
  726.  
  727. #define CHECK_AUX(dcontext, reg) \
  728.    if ((reg < 1) || (reg >= DC_NUM_AUX)) \
  729.       dc_error (dcontext->handle, \
  730.          "Bad auxiliary register number: %d", reg)
  731.    /* CHECK_AUX is not used for location pseudo-register. */
  732.  
  733. #define CHECK_BIT(dcontext, bit) \
  734.    if ((bit < 0) || (bit >= 32)) \
  735.       dc_error (dcontext->handle, \
  736.          "Bad bit number: %d", bit)
  737.  
  738.  
  739.  
  740. typedef struct cr_value {
  741.    int reg;
  742.    unsigned int off;
  743.  } dc_cr_value_t;
  744.  
  745. #define DC_UNDEF 32
  746.  
  747. /*
  748.    A "dc_cr_value" represents an execution-time value symbolically, in
  749.    terms of the initial value of a register (the value on entry to
  750.    the procedure being analyzed) and a known offset.  A value with
  751.    a 'reg' field value of 0 through 31 represents the value obtained
  752.    by summing (using 32-bit modulus arithmetic) the initial value of
  753.    register 'reg' and the value 'off'.  Note that the value (0,k)
  754.    represents the constant value k, that (31,0) represents the CFA, and
  755.    that (1,0) represents the return address.  A value with a 'reg' field
  756.    of DC_UNDEF represents an indeterminable value; in this case the
  757.    'off' field is undefined.  Other values of 'reg' are erroneous.
  758. */
  759.  
  760. typedef struct cr_data {
  761.    dc_cr_value_t reg_val[DC_NUM_REG];
  762.    dc_word_t saved;
  763.    dc_word_t how;
  764.    unsigned int where[DC_NUM_REG];
  765. } dc_cr_data_t;
  766.  
  767. /*
  768.    'cr_data' collects all the information needed to represent the
  769.    symbolic machine state during code reading.
  770.  
  771.    The 'reg_val' array gives the current dc_cr_value for each register.
  772.    
  773.    The 'saved', 'how', and 'where' fields combine to describe what
  774.    registers have been saved, and where.  The 'saved' and 'how' fields
  775.    are implicitly bit arrays over 0..31, where the numbering is from
  776.    0 on the right.  (Hence, 1<<r gives the mask for register r.)
  777.    If saved[r] is 0, the register is not saved, and how[r] and where[r]
  778.    are undefined.  If saved[r] is 1, then how[r] tells whether register r
  779.    was saved in another register (how[r]==0) or in the frame (how[r]==1).
  780.    In the former case, where[r] gives the register number; in the latter
  781.    case, where[r] gives the frame position.
  782. */
  783.  
  784.  
  785. typedef int dc_register_state_t;    /* range 0 to 2 */
  786.  
  787. #define DC_INVALID  0
  788. #define DC_READABLE 1
  789. #define DC_WRITABLE 2
  790.  
  791.  
  792.  
  793.  
  794. typedef struct dcontext_info {
  795.    dc_handle_t handle;                     /* environment of context */
  796.    dc_word_t reg_info[DC_NUM_REG];
  797.    dc_word_t reg_flags[2];
  798.    dc_word_t aux_info[DC_NUM_AUX];
  799.    dc_word_t aux_flags[2];
  800.    dc_exactness_t loc_exact;
  801.    dc_word_t psr_info;                     /* value or address */
  802.    dc_word_t psr_ind;                      /* DC_TRUE iff address */
  803.    dc_word_t psr_flags[2];                 /* per-PSR-bit flags */
  804.    unsigned int code_reading;               /* no tdesc therefore must read code*/
  805.      union {
  806.        tdesc_elem_t *tdesc_elem_ptr;       /* locates tdesc chunk */
  807.        dc_cr_data_t *cr_data_ptr;          /* or code reading data */
  808.      } info_ptr;
  809. } dcontext_info_t;
  810.  
  811. typedef dcontext_info_t *dc_dcontext_t;
  812.  
  813. dc_word_t dc_get_value (handle, info, flags, pos)
  814.    dc_handle_t handle;
  815.    dc_word_t info[];
  816.    dc_word_t flags[2];
  817.    int pos;
  818.    /* Assumes either DC_READABLE or DC_WRITABLE. */
  819. {
  820.    if (bit_test(flags[0], pos)) {
  821.       /* DC_WRITABLE case */
  822.       return dc_read_word(handle, info[pos]);
  823.    } else {
  824.       /* DC_READABLE case */
  825.       return info[pos];
  826.    }
  827. }
  828.  
  829. void dc_set_value (handle, info, flags, pos, value)
  830.    dc_handle_t handle;
  831.    dc_word_t info[];
  832.    dc_word_t flags[2];
  833.    int pos;
  834.    dc_word_t value;
  835.    /* Assumes DC_WRITABLE. */
  836. {
  837.    dc_write_word(handle, info[pos], value);
  838. }
  839.  
  840.  
  841. #define GET_REG_VALUE(dcontext, reg) \
  842.    dc_get_value(dcontext->handle, dcontext->reg_info, dcontext->reg_flags, reg)
  843.  
  844. #define SET_REG_VALUE(dcontext, reg, value) \
  845.    dc_set_value(dcontext->handle, dcontext->reg_info, dcontext->reg_flags, reg, \
  846.       value)
  847.  
  848. #define GET_AUX_VALUE(dcontext, reg) \
  849.    dc_get_value(dcontext->handle, dcontext->aux_info, dcontext->aux_flags, reg)
  850.  
  851. #define SET_AUX_VALUE(dcontext, reg, value) \
  852.    dc_set_value(dcontext->handle, dcontext->aux_info, dcontext->aux_flags, reg, \
  853.       value)
  854.  
  855.  
  856.  
  857. void dc_check_dcontext (dc)
  858.    dc_dcontext_t dc;
  859.    /* Check consistency of information supplied to make a dcontext. */
  860. {
  861.    int i;
  862.  
  863.    if ((REG_STATE(dc, 0) != DC_READABLE) || (dc->reg_info[0] != 0))
  864.       dc_error (dc->handle, "Register 0 is misspecified");
  865.    for (i = 1; i < DC_NUM_REG; i++)
  866.       if (REG_STATE(dc, i) == DC_RESERVED)
  867.          dc_error (dc->handle,
  868.             "State for general register %d is incorrect", i);
  869.    for (i = 0; i < DC_NUM_AUX; i++)
  870.       if (AUX_STATE(dc, i) == DC_RESERVED)
  871.          dc_error (dc->handle,
  872.             "State for auxiliary register %d is incorrect", i);
  873.    if (AUX_STATE(dc, DC_AUX_LOC) == DC_INVALID)
  874.       dc_error (dc->handle, "Location is specified as invalid");
  875.    if (GET_AUX_VALUE(dc, DC_AUX_LOC) == 0)
  876.       dc_error (dc->handle, "Location is zero.");
  877.    if (dc->loc_exact >= 3)
  878.       dc_error (dc->handle, "Location exactness is incorrectly specified: %d",
  879.          dc->loc_exact);
  880.    if (dc->psr_ind >= 2)
  881.       dc_error (dc->handle,
  882.          "PSR indirection flag is incorrectly specified: %d",
  883.          dc->psr_ind);
  884.    for (i = 0; i < 32; i++)
  885.       if (PSR_STATE(dc, i) == DC_RESERVED)
  886.          dc_error (dc->handle, "State for PSR bit %d is incorrect", i);
  887. }
  888.  
  889.  
  890.  
  891. tdesc_elem_t * dc_tdesc_lookup (loc, tt, tt_size, map_info_in_ptr)
  892.    dc_word_t loc;
  893.    tdesc_table_t tt;
  894.    int tt_size;
  895.    dc_map_info_in_t *map_info_in_ptr;
  896.    /* Return address of tdesc_elem_t for given location, or NULL if
  897.       there is no tdesc chunk for the location.
  898.    */
  899. {
  900.    int l = 0;
  901.    int h = tt_size;
  902.    int m;
  903.  
  904.    if (tt_size == 0) {
  905.       map_info_in_ptr->flags = 0;
  906.       return (tdesc_elem_t *)NULL;
  907.    }
  908.    for (;;) {
  909.       m = (l + h) / 2;
  910.       if (m == l) break;
  911.       if (loc >= tt[m].start_address)
  912.          l = m;
  913.       else
  914.          h = m;
  915.    }
  916.    if (loc >= tt[m].end_address) {
  917.       map_info_in_ptr->preceding_tdesc_end = tt[m].end_address;
  918.       if (m+1 < tt_size) {
  919.      map_info_in_ptr->following_tdesc_start = tt[m+1].start_address;
  920.      map_info_in_ptr->flags = DC_MII_PRECEDING_TDESC_END |
  921.                               DC_MII_FOLLOWING_TDESC_START;
  922.       } else {
  923.      map_info_in_ptr->flags = DC_MII_PRECEDING_TDESC_END;
  924.       }
  925.       return (tdesc_elem_t *)NULL;
  926.    } else if (loc < tt[m].start_address) {
  927.       map_info_in_ptr->following_tdesc_start = tt[m].start_address;
  928.       map_info_in_ptr->flags = DC_MII_FOLLOWING_TDESC_START;
  929.       return (tdesc_elem_t *)NULL;
  930.    } else {
  931.       return (&tt[m]);
  932.    }
  933. }
  934.  
  935.  
  936.  
  937. dc_dcontext_t dc_make_dcontext (handle,
  938.                                 reg_info, reg_flags,
  939.                                 aux_info, aux_flags, loc_exact,
  940.                                 psr_info, psr_ind, psr_flags)
  941.    dc_handle_t handle;
  942.    dc_word_t reg_info[DC_NUM_REG];
  943.    dc_word_t reg_flags[2];
  944.    dc_word_t aux_info[DC_NUM_AUX];
  945.    dc_word_t aux_flags[2];
  946.    dc_exactness_t loc_exact;
  947.    dc_word_t psr_info;
  948.    dc_boolean_t psr_ind;
  949.    dc_word_t psr_flags[2];
  950. {
  951.    dc_dcontext_t dc = (dc_dcontext_t) dc_malloc (handle, sizeof(dcontext_info_t));
  952.    int i;
  953.    dc_map_info_in_t map_info_in;
  954.  
  955.    /* Fill in supplied content. */
  956.    dc->handle = ((dc_handle_t)handle);
  957.    for (i = 0; i < DC_NUM_REG; i++) dc->reg_info[i]  = reg_info[i];
  958.    for (i = 0; i < 2; i++)       dc->reg_flags[i] = reg_flags[i];
  959.    for (i = 0; i < DC_NUM_AUX; i++) dc->aux_info[i]  = aux_info[i];
  960.    for (i = 0; i < 2; i++)       dc->aux_flags[i] = aux_flags[i];
  961.    dc->loc_exact = loc_exact;
  962.    dc->psr_info = psr_info;
  963.    dc->psr_ind = psr_ind;
  964.    for (i = 0; i < 2; i++)       dc->psr_flags[i] = psr_flags[i];
  965.  
  966.    dc_check_dcontext(dc);
  967.  
  968.    /* Find tdesc information for the text chunk. */
  969.    {
  970. /***************************************************************/
  971. /* BUG 8/16/89 Found by hls.  Not zeroing EV bits of location. */
  972. /*                            SHOULD USE dc_location()!        */
  973. /*      dc_word_t loc = GET_AUX_VALUE(dc, DC_AUX_LOC);         */
  974. /***************************************************************/
  975.       dc_word_t loc = GET_AUX_VALUE(dc, DC_AUX_LOC) & ~3;
  976.       tdesc_elem_t *tep =
  977.          dc_tdesc_lookup(loc, ((dc_handle_t)handle)->tdesc_table,
  978.              ((dc_handle_t)handle)->tdesc_table_size,&map_info_in);
  979.       if (tep) {
  980.          dc->code_reading = 0;
  981.          dc->info_ptr.tdesc_elem_ptr = tep;
  982.       } else {
  983.       dc->code_reading = 1;
  984.       if (!dc->handle->map_fcn) {
  985.           dc_error (dc->handle, "No tdesc information for %#.8X and no map function supplied.",loc);
  986.       }
  987. /****************************************************************/
  988. /* BUG 9/18/89 Found by hls.  Not using dc_malloc()             */
  989. /* dc->info_ptr.cr_data_ptr= (dc_cr_data_t *)malloc(sizeof(dc_cr_data_t )); */
  990. /****************************************************************/
  991.       dc->info_ptr.cr_data_ptr= (dc_cr_data_t *)dc_calloc(dc->handle,1,sizeof(dc_cr_data_t ));
  992.       dc_read_code(loc,dc,map_info_in,dc->info_ptr.cr_data_ptr);
  993.       }
  994.    }
  995.  
  996.    return (dc_dcontext_t) dc;
  997. }
  998.  
  999.  
  1000.  
  1001. void dc_free_dcontext (dcontext)
  1002.    dc_dcontext_t dcontext;
  1003. {
  1004. /****************************************************************/
  1005. /* BUG 9/19/89 Found by hls.  Freeing non-pointer value.        */
  1006. /*      free((char *)dcontext->code_reading);                 */
  1007. /****************************************************************/
  1008.    if (dcontext->code_reading)
  1009.       free((char *)dcontext->info_ptr.cr_data_ptr);
  1010.    free((char *)dcontext);
  1011. }
  1012.  
  1013.  
  1014.  
  1015. dc_register_state_t dc_location_state (dcontext)
  1016.    dc_dcontext_t dcontext;
  1017. {
  1018.    return AUX_STATE(((dc_dcontext_t)dcontext), DC_AUX_LOC);
  1019. }
  1020.  
  1021.  
  1022. dc_exactness_t dc_location_exactness (dcontext)
  1023.    dc_dcontext_t dcontext;
  1024. {
  1025.    return ((dc_dcontext_t)dcontext)->loc_exact;
  1026. }
  1027.  
  1028.  
  1029. dc_word_t dc_location (dcontext)
  1030.    dc_dcontext_t dcontext;
  1031.    /* Return high 30 bits only. */
  1032. {
  1033.    /* Don't need: CHECK_AUX_READ (((dc_dcontext_t)dcontext), DC_AUX_LOC); */
  1034.    return GET_AUX_VALUE (((dc_dcontext_t)dcontext), DC_AUX_LOC) & ~3;
  1035. }
  1036.  
  1037.  
  1038. dc_boolean_t dc_location_in_text_chunk( dcontext, value )
  1039.    dc_dcontext_t dcontext;
  1040.    dc_word_t value;
  1041. {
  1042.    /* Check that new location is still within same text chunk. */
  1043.    tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
  1044. /********************************************************************/
  1045. /* Bug in predicate -- LS adjusted according to OCS documentation.. */
  1046. /*  if ((value < tep->start_address) || (value >= tep->end_address))*/
  1047. /********************************************************************/
  1048.    if ((value >= tep->start_address) && (value < tep->end_address))
  1049.         return DC_TRUE;
  1050.     else
  1051.         return DC_FALSE;
  1052.  
  1053. }
  1054.  
  1055.  
  1056. void dc_set_location (dcontext, value)
  1057.    dc_dcontext_t dcontext;
  1058.    dc_word_t value;
  1059.    /* Set high 30 bits only. */
  1060. {
  1061.    if (dc_location_in_text_chunk( dcontext, value ) != DC_TRUE)
  1062.       dc_warn (((dc_dcontext_t)dcontext)->handle,
  1063.          "New location is not in same text chunk.");
  1064.  
  1065.    CHECK_AUX_WRITE (((dc_dcontext_t)dcontext), DC_AUX_LOC);
  1066.    dc_write_masked_word (((dc_dcontext_t)dcontext)->handle,
  1067.       ((dc_dcontext_t)dcontext)->aux_info[DC_AUX_LOC], ~3, value);
  1068. }
  1069.  
  1070.  
  1071.  
  1072. dc_register_state_t dc_general_register_state (dcontext, reg)
  1073.    dc_dcontext_t dcontext;
  1074.    int reg;
  1075. {
  1076.    CHECK_REG (((dc_dcontext_t)dcontext), reg);
  1077.    return REG_STATE(((dc_dcontext_t)dcontext), reg);
  1078. }
  1079.  
  1080.  
  1081. dc_word_t dc_general_register (dcontext, reg)
  1082.    dc_dcontext_t dcontext;
  1083.    int reg;
  1084. {
  1085.    CHECK_REG (((dc_dcontext_t)dcontext), reg);
  1086.    CHECK_REG_READ (((dc_dcontext_t)dcontext), reg);
  1087.    return GET_REG_VALUE(((dc_dcontext_t)dcontext), reg);
  1088. }
  1089.  
  1090.  
  1091. void dc_set_general_register (dcontext, reg, value)
  1092.    dc_dcontext_t dcontext;
  1093.    int reg;
  1094.    dc_word_t value;
  1095. {
  1096.    CHECK_REG (((dc_dcontext_t)dcontext), reg);
  1097.    CHECK_REG_WRITE (((dc_dcontext_t)dcontext), reg);
  1098.    SET_REG_VALUE (((dc_dcontext_t)dcontext), reg, value);
  1099. }
  1100.  
  1101.  
  1102.  
  1103. dc_register_state_t dc_auxiliary_register_state (dcontext, reg)
  1104.    dc_dcontext_t dcontext;
  1105.    int reg;
  1106. {
  1107.    CHECK_AUX (((dc_dcontext_t)dcontext), reg);
  1108.    return AUX_STATE(((dc_dcontext_t)dcontext), reg);
  1109. }
  1110.  
  1111.  
  1112. dc_word_t dc_auxiliary_register (dcontext, reg)
  1113.    dc_dcontext_t dcontext;
  1114.    int reg;
  1115. {
  1116.    CHECK_AUX (((dc_dcontext_t)dcontext), reg);
  1117.    CHECK_AUX_READ (((dc_dcontext_t)dcontext), reg);
  1118.    return GET_AUX_VALUE(((dc_dcontext_t)dcontext), reg);
  1119. }
  1120.  
  1121.  
  1122. void dc_set_auxiliary_register (dcontext, reg, value)
  1123.    dc_dcontext_t dcontext;
  1124.    int reg;
  1125.    dc_word_t value;
  1126. {
  1127.    CHECK_AUX (((dc_dcontext_t)dcontext), reg);
  1128.    CHECK_AUX_WRITE (((dc_dcontext_t)dcontext), reg);
  1129.    SET_AUX_VALUE (((dc_dcontext_t)dcontext), reg, value);
  1130. }
  1131.  
  1132.  
  1133.  
  1134. dc_register_state_t dc_psr_register_bit_state (dcontext, bit)
  1135.    dc_dcontext_t dcontext;
  1136.    int bit;
  1137. {
  1138.    CHECK_BIT (((dc_dcontext_t)dcontext), bit);
  1139.    return PSR_STATE(((dc_dcontext_t)dcontext), bit);
  1140. }
  1141.  
  1142.  
  1143. dc_word_t dc_psr_register (dcontext)
  1144.    dc_dcontext_t dcontext;
  1145. {
  1146.    if (((dc_dcontext_t)dcontext)->psr_ind) {
  1147.       return dc_read_word(((dc_dcontext_t)dcontext)->handle,
  1148.                        ((dc_dcontext_t)dcontext)->psr_info);
  1149.    } else {
  1150.       return ((dc_dcontext_t)dcontext)->psr_info;
  1151.    }
  1152. }
  1153.  
  1154.  
  1155. void dc_set_psr_register (dcontext, mask, value)
  1156.    dc_dcontext_t dcontext;
  1157.    dc_word_t mask;
  1158.    dc_word_t value;
  1159.    /* Set bits of PSR corresponding to 1 bits in mask. */
  1160. {
  1161.    if (((dc_dcontext_t)dcontext)->psr_ind) {
  1162.       if (((((dc_dcontext_t)dcontext)->psr_flags[0] & mask) != mask) ||
  1163.           ((((dc_dcontext_t)dcontext)->psr_flags[1] & mask) != 0))
  1164.          dc_error (((dc_dcontext_t)dcontext)->handle,
  1165.             "Some PSR bits specified are not writable.");
  1166.       dc_write_masked_word (((dc_dcontext_t)dcontext)->handle,
  1167.                          ((dc_dcontext_t)dcontext)->psr_info, mask, value);
  1168.    } else {
  1169.       dc_error (((dc_dcontext_t)dcontext)->handle, "PSR is not writable.");
  1170.    }
  1171. }
  1172.  
  1173.  
  1174.  
  1175. dc_word_t dc_frame_address (dcontext)
  1176.    dc_dcontext_t dcontext;
  1177. {
  1178.   if (!dcontext->code_reading) {
  1179.      tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
  1180.      return dc_general_register(dcontext,
  1181.         tep->info.frame_address_register) + tep->info.frame_address_offset;
  1182.   } else {
  1183.      if (dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_FP].reg == DC_REG_SP) {
  1184.         return (dc_general_register(dcontext,DC_REG_FP)
  1185.             - dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_FP].off);
  1186.      }
  1187.      if (dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_SP].reg == DC_REG_SP) {
  1188.         return (dc_general_register(dcontext,DC_REG_SP)
  1189.             - dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_SP].off);
  1190.      }
  1191.      dc_error (((dc_dcontext_t)dcontext)->handle, "Cannot locate frame pointer.");
  1192.   }
  1193. }
  1194.  
  1195.  
  1196.  
  1197. dc_kind_t dc_context_kind (dcontext)
  1198.    dc_dcontext_t dcontext;
  1199. {
  1200.    return DC_CALL_KIND;
  1201. }
  1202.  
  1203.  
  1204.  
  1205.  
  1206. /* operations valid for call contexts only */
  1207.  
  1208.  
  1209. dc_register_state_t dc_return_address_state (dcontext)
  1210.    dc_dcontext_t dcontext;
  1211. {
  1212.    tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
  1213.    int reg;
  1214.  
  1215.    if (!dcontext->code_reading) {
  1216.       if (tep->info.return_address_info_discriminant) {
  1217.           return DC_WRITABLE;
  1218.       } else {
  1219.          return REG_STATE(((dc_dcontext_t)dcontext), tep->info.return_address_info);
  1220.       }
  1221.    } else {
  1222.       reg= DC_REG_RA;
  1223.       if (bit_test(dcontext->info_ptr.cr_data_ptr->saved,DC_REG_RA)) {
  1224.         if (bit_test(dcontext->info_ptr.cr_data_ptr->how,DC_REG_RA)) {
  1225.            return DC_WRITABLE;
  1226.         } else {
  1227.            reg= dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA];
  1228.         }
  1229.       }
  1230.         return REG_STATE(((dc_dcontext_t)dcontext),reg);
  1231.  
  1232.       
  1233.    }
  1234. }
  1235.  
  1236.  
  1237. dc_exactness_t dc_return_address_exactness (dcontext)
  1238.    dc_dcontext_t dcontext;
  1239. {
  1240.    return DC_MAYBE;
  1241. }
  1242.  
  1243.  
  1244. dc_word_t dc_return_address (dcontext)
  1245.    dc_dcontext_t dcontext;
  1246.    /* Return high 30 bits only. */
  1247. {
  1248.    tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
  1249.    dc_word_t rai = tep->info.return_address_info;
  1250.    dc_word_t val;
  1251.    int reg;
  1252.  
  1253.    if (!dcontext->code_reading) {
  1254.      if (tep->info.return_address_info_discriminant) {
  1255.         val = dc_read_word (((dc_dcontext_t)dcontext)->handle,
  1256.                          dc_frame_address(dcontext) + rai);
  1257.      } else {
  1258.         val = dc_general_register (dcontext, rai);
  1259.      }
  1260.    } else {
  1261.       reg=DC_REG_RA;
  1262.       if (bit_test(dcontext->info_ptr.cr_data_ptr->saved,reg)) {
  1263.           if (bit_test(dcontext->info_ptr.cr_data_ptr->how,reg)) {
  1264.              val = dc_read_word (((dc_dcontext_t)dcontext)->handle,
  1265.                            dc_frame_address(dcontext) + 
  1266.                             (dcontext->info_ptr.cr_data_ptr->where[reg]));
  1267.           } else {
  1268.              reg= dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA];
  1269.              val = dc_general_register (dcontext, reg);
  1270.           }
  1271.       } else {
  1272.          val = dc_general_register (dcontext, reg);
  1273.       }
  1274.    }
  1275.      return val & ~3;
  1276. }
  1277.  
  1278.  
  1279. void dc_set_return_address (dcontext, value)
  1280.    dc_dcontext_t dcontext;
  1281.    dc_word_t value;
  1282.    /* Set high 30 bits only. */
  1283. {
  1284.   if (!dcontext->code_reading) {
  1285.      tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr;
  1286.      dc_word_t rai = tep->info.return_address_info;
  1287.  
  1288.      if (tep->info.return_address_info_discriminant) {
  1289.         dc_write_masked_word (((dc_dcontext_t)dcontext)->handle,
  1290.            dc_frame_address(dcontext) + rai, ~3, value);
  1291.      } else {
  1292.       dc_set_general_register (dcontext, rai,
  1293.          (value & ~3) | (dc_general_register(dcontext, rai) & 3));
  1294.    }
  1295.  } else {
  1296.     if (bit_test(dcontext->info_ptr.cr_data_ptr->saved,DC_REG_RA)) {
  1297.         if (bit_test(dcontext->info_ptr.cr_data_ptr->how,DC_REG_RA)) {
  1298.            dc_write_masked_word (((dc_dcontext_t)dcontext)->handle,
  1299.               dc_frame_address(dcontext)
  1300.                + dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA], ~3, value);
  1301.           } else {
  1302.              dc_set_general_register( dcontext,
  1303.                                   dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA]);
  1304.           }
  1305.       } else {
  1306.           dc_set_general_register( dcontext,
  1307.                               dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA]);
  1308.       }
  1309.    }
  1310. }
  1311.  
  1312.  
  1313.  
  1314. /* operations valid for save contexts only */
  1315.  
  1316. /* (none) */
  1317.  
  1318.  
  1319.  
  1320. /* operations valid for exception contexts only */
  1321.  
  1322.  
  1323. void dc_get_exception_info (dcontext, handler, datum)
  1324.    dc_dcontext_t dcontext;
  1325.    dc_word_t *handler;
  1326.    dc_word_t *datum;
  1327. {
  1328.    dc_error (((dc_dcontext_t)dcontext)->handle,
  1329.       "dc_get_exception_info is not yet implemented.");
  1330. }
  1331.  
  1332.  
  1333.  
  1334. /* operations valid for protection contexts only */
  1335.  
  1336.  
  1337. void dc_get_protection_info (dcontext, handler, datum)
  1338.    dc_dcontext_t dcontext;
  1339.    dc_word_t *handler;
  1340.    dc_word_t *datum;
  1341. {
  1342.    dc_error (((dc_dcontext_t)dcontext)->handle,
  1343.       "dc_get_protection_info is not yet implemented.");
  1344. }
  1345.  
  1346.  
  1347.  
  1348. /* operations valid for special contexts only */
  1349.  
  1350.  
  1351. void dc_get_special_info (dcontext, kind, datum)
  1352.    dc_dcontext_t dcontext;
  1353.    dc_word_t *kind;
  1354.    dc_word_t *datum;
  1355. {
  1356.    dc_error (((dc_dcontext_t)dcontext)->handle,
  1357.       "dc_get_special_info is not yet implemented.");
  1358. }
  1359.  
  1360.  
  1361.  
  1362. /* operations valid for all contexts (again) */
  1363.  
  1364.  
  1365. dc_dcontext_t dc_previous_dcontext (dcontext)
  1366.    dc_dcontext_t dcontext;
  1367.    /* Return NULL if there is no previous context. */
  1368. {
  1369.    dc_dcontext_t old = (dc_dcontext_t) dcontext;
  1370.    dcontext_info_t new;    /* to serve as temporary storage only */
  1371.    tdesc_elem_t *tep;
  1372.     dc_cr_data_t *cdp;
  1373.    dc_word_t cfa;
  1374.    int rsm;
  1375.    dc_word_t offset;
  1376.    dc_word_t rai;
  1377.    int r;
  1378.  
  1379.    if (dc_return_address_state((dc_dcontext_t)old) == DC_INVALID)
  1380.       dc_error (old->handle, "Return address is invalid.");
  1381.  
  1382.    if (dc_return_address((dc_dcontext_t)old) == 0)
  1383.       return (dc_dcontext_t)NULL;  /* end of the chain */
  1384.  
  1385.    /* Copy over old contents. */
  1386.    new = *old;
  1387.  
  1388.    cfa = dc_frame_address(old);
  1389.     /* Restore stack pointer. */
  1390.     new.reg_info[DC_REG_SP] = cfa;
  1391.     SET_READABLE (new.reg_flags, DC_REG_SP);
  1392.  
  1393.    /* Invalidate temporary registers. */
  1394.    for (r = 1; r <= 13; r++) SET_INVALID (new.reg_flags, r);
  1395.  
  1396.     if (!old->code_reading) {
  1397.         tep = old->info_ptr.tdesc_elem_ptr;
  1398.         /* Restore preserved registers. */
  1399.         rsm = tep->info.register_save_mask;
  1400.         offset = cfa + tep->info.register_save_offset;
  1401.         for (r = 14; r <= 30; r++) {
  1402.             if (bit_test(rsm, 30-r)) {
  1403.                 new.reg_info[r] = offset;
  1404.                 SET_WRITABLE (new.reg_flags, r);
  1405.                 offset += sizeof(dc_word_t);
  1406.             }
  1407.         }
  1408.  
  1409.         /* Set location from old return address. */
  1410.         rai = tep->info.return_address_info;
  1411.         if (tep->info.return_address_info_discriminant) {
  1412.             new.aux_info[DC_AUX_LOC] = cfa + rai;
  1413.             SET_WRITABLE (new.aux_flags, DC_AUX_LOC);
  1414.         } else {
  1415.             new.aux_info[DC_AUX_LOC] = old->reg_info[rai];
  1416.             ASSIGN_RSTATE (new.aux_flags, DC_AUX_LOC, old->reg_flags, rai);
  1417.         }
  1418.     } else {
  1419.         cdp = old->info_ptr.cr_data_ptr;
  1420.         
  1421.         /* Restore preserved registers. */
  1422.         for (r = 14; r <= 30; r++) { 
  1423.             if (bit_test(cdp->saved,r)) {
  1424.                 if (bit_test(cdp->how,r)){ /* saved in the frame */
  1425.                     new.reg_info[r] = cfa+cdp->where[r];
  1426.                     SET_WRITABLE (new.reg_flags, r);
  1427.                 } else { /* saved in the in a register */
  1428.                     new.reg_info[r] = dc_general_register(old,cdp->where[r]);
  1429.                     ASSIGN_RSTATE (new.aux_flags, r, old->reg_flags, cdp->where[r]);
  1430.                 }
  1431.             }  /* not saved, therefore, already valid , no else*/
  1432.         }
  1433.  
  1434.         /* Set location from old return address. */
  1435.         if (bit_test(cdp->saved,DC_REG_RA)) {
  1436.             if (bit_test(cdp->how,DC_REG_RA)){ /* saved in the frame */
  1437.                 new.aux_info[DC_AUX_LOC] = 
  1438.                     new.reg_info[DC_REG_RA] = cfa+cdp->where[DC_REG_RA];
  1439.                 SET_WRITABLE (new.reg_flags, DC_REG_RA);
  1440.                 SET_WRITABLE (new.aux_flags, DC_AUX_LOC);
  1441.             } else { /* saved in the in a register */
  1442.                 new.reg_info[DC_REG_RA] =
  1443.                     new.aux_info[DC_AUX_LOC] =
  1444.                             dc_general_register(old,cdp->where[DC_REG_RA]);
  1445.                 ASSIGN_RSTATE (new.aux_flags, DC_AUX_LOC, 
  1446.                                     old->reg_flags, cdp->where[DC_REG_RA]);
  1447.             }
  1448.         } else { /* not saved, therefore, already valid , set DC_AUX_LOC only*/
  1449.                 new.aux_info[DC_AUX_LOC] =
  1450.                         dc_general_register(old,DC_REG_RA);
  1451.                 ASSIGN_RSTATE (new.aux_flags, DC_AUX_LOC, 
  1452.                                     old->reg_flags, DC_REG_RA);
  1453.         }
  1454.     }
  1455.  
  1456.    /* Invalidate instruction pointers. */
  1457.    SET_INVALID (new.aux_flags, DC_AUX_SXIP);
  1458.    SET_INVALID (new.aux_flags, DC_AUX_SNIP);
  1459.    SET_INVALID (new.aux_flags, DC_AUX_SFIP);
  1460.  
  1461.    /* No change to FCR registers. */
  1462.  
  1463.    /* No change to PSR register. */
  1464.  
  1465.    return dc_make_dcontext ((dc_handle_t)new.handle,
  1466.                             new.reg_info, new.reg_flags,
  1467.                             new.aux_info, new.aux_flags, new.loc_exact,
  1468.                             new.psr_info, new.psr_ind, new.psr_flags);
  1469. }
  1470.  
  1471.  
  1472.  
  1473. /* extensions for nonlocal goto */
  1474.  
  1475. #if 0
  1476.  
  1477. typedef
  1478.    struct label {
  1479.       ???
  1480.    } label_t;
  1481.  
  1482.  
  1483. label_t dc_make_label (dcontext, location)
  1484.    dc_dcontext_t dcontext;
  1485.    dc_word_t location;
  1486. {
  1487. }
  1488.  
  1489. #endif
  1490.  
  1491. /* procedure for reading code */
  1492.  
  1493. dc_read_code(loc,dc,map_info_in,cdp)
  1494. dc_word_t loc;
  1495. dc_dcontext_t dc;
  1496. dc_cr_data_t *cdp;
  1497. dc_map_info_in_t map_info_in;
  1498. {
  1499. dc_map_info_out_t map_info_out;
  1500. dc_word_t pc;
  1501. dc_boolean_t found_branch=DC_FALSE;
  1502. dc_word_t instr;
  1503.  
  1504.     (*dc->handle->map_fcn)(dc->handle->map_env,loc,map_info_in,&map_info_out);
  1505.     if (map_info_out.flags & DC_MIO_ENTRY_POINT 
  1506.         && (!(map_info_in.flags & DC_MII_PRECEDING_TDESC_END)
  1507.             || map_info_out.entry_point >= map_info_in.preceding_tdesc_end
  1508.             || map_info_out.flags & DC_MIO_LITERAL_ENTRY_POINT)) {
  1509.        dc_init_cr_data(cdp,(tdesc_elem_t *)NULL);
  1510.        pc= map_info_out.entry_point;
  1511.     } else if (map_info_in.flags & DC_MII_PRECEDING_TDESC_END) { 
  1512.         /**/
  1513.         /* tdesc_lookup gets the tep for the preceeding tdesc information
  1514.         /* so we call it with one less than the preceding tdesc end since
  1515.         /* tdesc information is exclusive of the ending address
  1516.         /**/
  1517.        dc_init_cr_data(cdp, 
  1518.                        dc_tdesc_lookup(map_info_in.preceding_tdesc_end-1, 
  1519.                                     ((dc_handle_t)dc->handle)->tdesc_table,
  1520.                                      ((dc_handle_t)dc->handle)->tdesc_table_size,
  1521.                                     &map_info_in));
  1522.        pc= map_info_in.preceding_tdesc_end;
  1523.     } else {
  1524.       dc_error (dc->handle, "Insufficient information for code reading.");
  1525.     }
  1526.     for (;;pc+=4) {
  1527.         if (pc==loc) {
  1528.            return (DC_TRUE);
  1529.         }
  1530.         instr= dc_read_word(dc->handle,pc);
  1531.         found_branch= dc_decode_finds_branch(dc,instr);
  1532.         if ((map_info_out.flags & DC_MIO_PROLOGUE_END) 
  1533.               && (pc==map_info_out.prologue_end)) {
  1534.             break;
  1535.         }
  1536.         if (found_branch) {
  1537.             if (DC_MIO_IMPLICIT_PROLOGUE_END & map_info_out.flags) {
  1538.                 break;
  1539.             } else {
  1540.                   dc_error (dc->handle, "Found branch before end of prologue.");
  1541.             }
  1542.         }
  1543.     }
  1544.     if (!(map_info_out.flags & DC_MIO_LITERAL_EPILOGUE_START)
  1545.          && (map_info_out.epilogue_start >= loc 
  1546.                 || !(map_info_out.flags & DC_MIO_EPILOGUE_START))) {
  1547.         return (DC_TRUE);
  1548.     }
  1549.     dc_correct_cr_data(cdp,dc->handle);
  1550.     for (pc=map_info_out.epilogue_start;pc<loc;pc+=4) {
  1551.         instr= dc_read_word(dc->handle,pc);
  1552.         if (dc_decode_finds_branch(dc,instr)) {
  1553.             return (DC_FALSE);
  1554.         }
  1555.     }
  1556.     return (DC_TRUE);
  1557.  
  1558. }
  1559.  
  1560.  
  1561.  
  1562. dc_init_cr_data(cdp,tep)
  1563. dc_cr_data_t *cdp;
  1564. tdesc_elem_t *tep;
  1565. {
  1566. int reg;
  1567. dc_word_t rai;
  1568. dc_word_t raid;
  1569. dc_word_t rsm;
  1570. dc_word_t frpos;
  1571.  
  1572.     if (tep){
  1573.  
  1574.        /* Start off with all registers undefined and none saved. */
  1575.        for (reg = 0; reg < DC_NUM_REG; reg++) {
  1576.           cdp->reg_val[reg].reg = DC_UNDEF;
  1577.        }
  1578.        cdp->saved = 0;
  1579.  
  1580.        /* Overwrite with what tdesc element says. */
  1581.  
  1582.        cdp->reg_val[tep->info.frame_address_register].reg = DC_REG_SP;
  1583.        cdp->reg_val[tep->info.frame_address_register].off =
  1584.                   - tep->info.frame_address_offset;
  1585.  
  1586.        rai = tep->info.return_address_info;
  1587.        raid = tep->info.return_address_info_discriminant;
  1588.        if (raid || rai != DC_REG_RA) {
  1589.           bit_set(cdp->saved,DC_REG_RA);
  1590.           bit_assign(cdp->how,DC_REG_RA,raid);
  1591.           cdp->where[DC_REG_RA] = rai;
  1592.        }
  1593.  
  1594.        rsm = tep->info.register_save_mask;
  1595.        frpos = tep->info.register_save_offset;
  1596.        for (reg = 14; reg <= 30; reg++) {
  1597.             if (bit_test(rsm, 30-reg)) {
  1598.                 bit_set(cdp->saved,reg);
  1599.                 bit_set(cdp->how,reg);
  1600.                 cdp->where[reg] = frpos;
  1601.                 frpos += sizeof(dc_word_t);
  1602.             } else {
  1603.                     cdp->reg_val[reg].reg = reg;
  1604.                     cdp->reg_val[reg].off = 0;
  1605.             }
  1606.        }
  1607.  
  1608.        cdp->reg_val[0].reg = 0;   /* guarantee what hardware does */
  1609.        cdp->reg_val[0].off = 0;
  1610.  
  1611.     } else {
  1612.        /* Each register has its own initial value. */
  1613.        for (reg = 0; reg < DC_NUM_REG; reg++) {
  1614.           cdp->reg_val[reg].reg = reg;
  1615.           cdp->reg_val[reg].off = 0;
  1616.        }
  1617.    /* No register is yet saved. */
  1618.    cdp->saved = 0;
  1619.    cdp->how = 0;
  1620.     }
  1621. }
  1622. void dc_correct_cr_data(cdp,handle)
  1623. dc_cr_data_t *cdp;
  1624. dc_handle_t handle;
  1625. {
  1626. long sr,r;
  1627. dc_word_t save_regs = 0;  /* registers used to save others */
  1628.    for (r = 1; r < DC_REG_SP; r++) {
  1629.       if (bit_test(cdp->saved,r) && !bit_test(cdp->how,r)) {
  1630.          sr = cdp->where[r];
  1631.          if (bit_test(save_regs,sr)) {
  1632.             dc_error(handle, "Same register used to save two others.");
  1633.      }
  1634.          bit_set(save_regs,sr);
  1635.       }
  1636.    }
  1637.    for (r = 1; r < DC_REG_FP; r++) {
  1638.       if ((r < 14 || bit_test(cdp->saved,r)) && !bit_test(save_regs,r)) {
  1639.          cdp->reg_val[r].reg = DC_UNDEF;
  1640.       }
  1641.    }
  1642.    if (bit_test(cdp->saved,DC_REG_FP) &&
  1643.        cdp->reg_val[DC_REG_FP].reg == DC_REG_SP) {  /* is r30 the far? */
  1644.       cdp->reg_val[DC_REG_SP].reg = DC_UNDEF;  /* trash sp */
  1645.    } else if (cdp->reg_val[DC_REG_SP].reg == DC_REG_SP) { /* is r31 the far? */
  1646.       if (bit_test(cdp->saved,DC_REG_FP) && !bit_test(save_regs,DC_REG_FP)) {
  1647.          cdp->reg_val[DC_REG_FP].reg = DC_UNDEF;  /* trash r30 */
  1648.       }
  1649.    }
  1650. }
  1651.